package org.example.study4;
//
// 所有线程通过竞争类对象锁来同步对静态变量 count 的修改，最终结果严格等于预期的 10 万。

/**
 * 用类对象做为锁对象
 * 展示了通过类级别锁（synchronized (Counter409.class)）保护静态变量的线程安全机制。
 * 所有线程通过竞争类对象锁来同步对静态变量 count 的修改
 */
public class Demo_409 {
    public static void main(String[] args) throws InterruptedException {
        // 初始化两个不同的 Counter409 实例
        Counter409 counter = new Counter409(); // 实例1
        Counter409 counter1 = new Counter409(); // 实例2

        // 创建两个线程，分别操作不同的实例
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                counter.increase(); // 线程1调用实例1的 increase()
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                counter1.increase(); // 线程2调用实例2的 increase()
            }
        });

        // 启动线程
        t1.start(); // 线程1操作实例1
        t2.start(); // 线程2操作实例2

        // 等待线程结束
        t1.join();
        t2.join();

        // 输出结果（必为 10 万）
        System.out.println("count = " + Counter409.count);
    }
}

class Counter409 {
    public static int count = 0; // 静态变量，类级别共享

    /**
     * 累加方法（使用类级别锁同步）
     */
    public void increase() {
        synchronized (Counter409.class) { // 锁定类对象（Counter409.class）
            count++; // 原子操作（在同步保护下）
        }
    }
}

// 运行： count = 100000

/*
1. 类级别锁的作用
synchronized (Counter409.class)：锁定 Counter409 的类对象（Class 对象）。
所有实例的线程在调用 increase() 时，竞争同一把类锁。
保证静态变量 count 的修改是原子的。

2. 静态变量与类锁的匹配
静态变量 count：属于类级别，所有实例共享。
类锁的作用域：锁的作用域与变量的作用域一致，确保所有线程通过同一锁同步。

*/

/*
Demo_408：显式定义静态锁对象 static Object locker。
Demo_409：直接使用类对象（Counter409.class）作为锁。
本质相同：两种方式锁定的对象均为类级别，效果一致。
Demo_409 更简洁：无需额外定义静态锁对象，直接使用 ClassName.class 更直观。*/


/*类级别锁的原理
类对象唯一性：JVM 中每个类的 Class 对象是唯一的，所有线程通过 synchronized (ClassName.class) 竞争同一锁。
适用场景：保护静态变量或需要跨实例同步的操作。
*/

/*总结
核心设计：通过类级别锁（synchronized (ClassName.class)）保护静态变量，确保多实例环境下线程安全。
解决问题：修复了实例锁（Demo_406）和显式静态锁（Demo_408）可能存在的设计冗余或潜在问题。
现象：结果严格正确，证明类锁的有效性。
实际意义：展示了类级别锁在多实例环境中的标准用法，是保护静态资源的推荐方案。*/

